
// 泛型

// function fn<T>(a: T): T {
// 	return a
// }

// const num = fn<number>(1)
// const str = fn<string>('123')


// 泛型变量
// const arr1: number[] = [1, 2, 3, 4, 5]
// const arr2: Array<number> = [1, 2, 3, 4, 5]

// function loggingIdentity<T>(arg: T[]): T[] {
// 	console.log(arg.length);  // Error: T doesn't have .length
// 	return arg;
// }

// const arr = loggingIdentity<number>([1, 2, 3, 4, 5])


// 泛型类型
// function identity<T>(arg: T): T {
// 	return arg;
// }


// let myIdentity: <T>(arg: T) => T = identity;

// 这引导我们去写第一个泛型接口了。 我们把上面例子里的对象字面量拿出来做为一个接口：
// 泛型接口
// interface FnType {
// 	<T>(arg: T): T
// }


// const fn: FnType = <QWE>(arg: QWE) => arg


// 泛型类
// class Person<T, U> {
// 	name: T
// 	age: U

// 	say<T>(value: T) {
// 		return value
// 	}
// }

// const p1 = new Person<string, string>()

// p1.name = '张三'
// p1.age = '18'

// const result = p1.say<string>('哈哈')
// console.log(result);

// const reuslt1 = p1.say<number>(11)
// console.log(reuslt1);


// 泛型约束

// function fn<T extends { length: number }>(args: T): number {
// 	return args.length
// }

// const len = fn('1231231')
// const len1 = fn([1,2,3,4])
// const len2 = fn({ length: 1231 })





function countConsistentStrings(str: string, arr: string[]): number {
	let num = 0;
	arr.forEach(v => {
		const newArr = [...new Set(v.split(''))]
		console.log(newArr);
	})

	return num
}


const result1 = countConsistentStrings('ab', ['ab', 'ad', 'adc', 'aaaab', 'aaaabd'])